home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 010 / blit.arc / RLAYEROP.C < prev    next >
Text File  |  1985-05-23  |  4KB  |  112 lines
  1. /*
  2.  * name:         rlayerop
  3.  *
  4.  * description: given a layer lp, a rectangle r, a bitmap operator fn,
  5.  *              and the obscured list of the layer op, recursively chain
  6.  *              along the obscured list of the layer, performing the
  7.  *              operation on the intersection of the argument rectangle
  8.  *               and the obscured bitmap, and pass nonintersecting portions on
  9.  *              to be intersected with other bitmaps on the obscured list.
  10.  *              when the obscured list is empty, the rectangle must be drawn
  11.  *               on the screen.
  12.  *
  13.  * synopsis:     rlayerop (lp, fn, r, op, p1, p2, p3, p4)
  14.  *              struct layer    *lp;
  15.  *              int      (*fn) ();
  16.  *              struct rectangle    *r;
  17.  *              struct obscured *op;
  18.  *              int     *p1;
  19.  *              int     *p2;
  20.  *              int     *p3;
  21.  *              int     *p4;
  22.  *
  23.  * globals:      display  (r/w)
  24.  *
  25.  * calls:        (*fn) <=> addpiece  (addpiece.c)  by newlayer  (newlayer.c)
  26.  *                        lbblt      (lbblt.c)        lblt      (lblt.c)
  27.  *                        pass       (pass.c)         lbitblt   (lbitblt.c)
  28.  *              rectxrect            (rectxrect.c)
  29.  *              rlayerop             (rlayerop.c)
  30.  *
  31.  * called by:    layerop   (layerop.c)
  32.  *              rlayerop   (rlayerop.c)
  33.  */
  34. #include "layers.h"
  35.  
  36. extern struct bitmap  *display;
  37.  
  38. rlayerop (lp, fn, r, op, p1, p2, p3, p4)
  39. struct layer  *lp;
  40. int    (*fn) ();
  41. struct rectangle  *r;
  42. struct obscured *op;                  /* element of obscured list with which
  43.                                          to intersect r */
  44. int   *p1;
  45. int   *p2;
  46. int   *p3;
  47. int   *p4;
  48. {
  49.    struct rectangle     temp;
  50.  
  51.  /*
  52.  * recursively subdivide and intersect rectangle r
  53.  * with the obscured bitmaps in layer lp.
  54.  */
  55.    if (op == null)                     /* this rectangle is not obscured */
  56.         (void) (*fn) (lp, r, display, op, p1, p2, p3, p4);/* draw on screen */
  57.    else
  58.         if (rectxrect (r, &(op -> ob_rect)) == false)/* they miss */
  59.            (void) rlayerop (lp, fn, r, op -> ob_next, p1, p2, p3, p4);
  60.  /* chain */
  61.        else {                          /* they must intersect */
  62.            if (r -> origin.y < op -> ob_rect.origin.y) {
  63.             /*
  64.             * temp = piece of r below op -> rect;
  65.              */
  66.                temp.origin.x = r -> origin.x;
  67.                temp.origin.y = r -> origin.y;
  68.                temp.corner.x = r -> origin.x;
  69.                temp.corner.y = op -> ob_rect.origin.y;
  70.                (void) rlayerop (lp, fn, &temp, op -> ob_next, p1, p2, p3, p4);
  71.                r -> origin.y = op -> ob_rect.origin.y;
  72.            }
  73.            if (r -> corner.y > op -> ob_rect.corner.y) {
  74.             /*
  75.             * temp = piece of r above op -> rect;
  76.              */
  77.                temp.origin.x = r -> origin.x;
  78.                temp.origin.y = op -> ob_rect.corner.y;
  79.                temp.corner.x = r -> origin.x;
  80.                temp.corner.y = r -> origin.y;
  81.                (void) rlayerop (lp, fn, &temp, op -> ob_next, p1, p2, p3, p4);
  82.                r -> corner.y = op -> ob_rect.corner.y;
  83.            }
  84.            if (r -> origin.x < op -> ob_rect.origin.x) {
  85.             /*
  86.             * temp = piece of r to the left of op -> rect;
  87.              */
  88.                temp.origin.x = r -> origin.x;
  89.                temp.origin.y = r -> origin.y;
  90.                temp.corner.x = op -> ob_rect.origin.x;
  91.                temp.corner.y = r -> origin.y;
  92.                (void) rlayerop (lp, fn, &temp, op -> ob_next, p1, p2, p3, p4);
  93.                r -> origin.x = op -> ob_rect.origin.x;
  94.            }
  95.            if (r -> corner.x > op -> ob_rect.corner.x) {
  96.             /*
  97.             * temp = piece of r right of op -> rect;
  98.              */
  99.                temp.origin.x = op -> ob_rect.corner.x;
  100.                temp.origin.y = r -> origin.y;
  101.                temp.corner.x = r -> origin.x;
  102.                temp.corner.y = r -> origin.y;
  103.                (void) rlayerop (lp, fn, &temp, op -> ob_next, p1, p2, p3, p4);
  104.                r -> corner.x = op -> ob_rect.corner.x;
  105.            }
  106.        /*
  107.         * what's left goes in this obscured bitmap
  108.         */
  109.            (void) (*fn) (lp, r, op -> ob_bmap, op, p1, p2, p3, p4);
  110.        }
  111. }
  112.